04 第4章：部署实战（含代码）

第4章：部署实战（含代码）

掌握了大模型私有化部署的核心概念和硬件规划后，本章将进入激动人心的实战环节。我们将手把手指导您完成 DeepSeek 大模型的部署，从简单的单机快速启动，到复杂的集群编排，再到实用的模型量化和版本管理，力求通过丰富的代码示例和操作步骤，让您真正掌握 DeepSeek 大模型的私有化落地技能。

单机部署：使用 Hugging Face transformers 和 fschat 快速启动

对于初步测试、开发验证或对并发性能要求不高的场景，单机部署是最快捷的方案。DeepSeek 模型作为 Hugging Face 生态系统的重要组成部分，可以直接利用 transformers 库进行加载和推理。为了提供一个易于调用的 API 接口，我们通常会结合 fschat 这样的开源项目来封装推理服务。

前提条件：

一台配置有 NVIDIA GPU（推荐 24GB 显存或更高）的 Linux 服务器。
已安装 NVIDIA 驱动和 CUDA 工具包（确保版本兼容 PyTorch）。
已安装 Python 3.8+ 及 pip 包管理器。

操作步骤：

安装所需 Python 库：

我们将安装 Hugging Face 的核心库 transformers 和 PyTorch，以及用于加速推理的 accelerate。同时，为了提供一个类似 OpenAI API 的接口，我们安装 fschat 及其必要的组件。

pip install transformers torch accelerate
pip install "fschat[model_worker,webui]" # 安装 fschat 及模型工作节点和 Web UI 相关依赖

出处：transformers 和 torch 是 Hugging Face 和 PyTorch 官方维护的深度学习库，accelerate 也是 Hugging Face 的加速工具，这些都是业界标准。fschat 是一个流行的用于 LLM 服务和 API 的开源项目，由 LMSYS Org 维护，您可以在 LMSYS FastChat GitHub 仓库找到其详细信息。
下载 DeepSeek 模型权重并进行推理：

从 Hugging Face 模型 Hub 下载您选择的 DeepSeek 模型权重。以 deepseek-ai/deepseek-moe-16b-chat 为例，这是一个基于 MoE 架构的聊天模型。

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "deepseek-ai/deepseek-moe-16b-chat"

# 加载 Tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 加载模型
# 使用 bfloat16 精度加载模型，以节省显存并加速推理（适用于支持 bfloat16 的 GPU，如 A100/H100）
# 如果GPU不支持 bfloat16 或显存不足，可以尝试 torch.float16 或加载量化版本。
# device_map="auto" 会自动将模型层分配到可用的设备（GPU/CPU）。
model = AutoModelForCausalLM.from_pretrained(model_name,
                                             torch_dtype=torch.bfloat16,
                                             device_map="auto",
                                             trust_remote_code=True) # DeepSeek模型可能需要trust_remote_code
model.eval() # 设置模型为评估模式

print(f"DeepSeek model {model_name} loaded successfully to GPU(s).")

# 简单推理示例
messages = [
    {"role": "user", "content": "Hello, how are you today?"},
]

# 将消息列表转换为模型所需的输入格式
# DeepSeek 模型通常遵循 ChatML 格式或其他特定聊天模板
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

# 生成响应
with torch.no_grad():
    outputs = model.generate(**inputs,
                             max_new_tokens=100,
                             do_sample=True,
                             temperature=0.7,
                             top_p=0.9,
                             eos_token_id=tokenizer.eos_token_id)

response_tokens = outputs[0][inputs["input_ids"].shape[1]:] # 移除输入部分
response = tokenizer.decode(response_tokens, skip_special_tokens=True)
print("Model Response:", response)

出处：DeepSeek 模型权重托管在 Hugging Face 模型 Hub 上，这是业界标准的模型共享平台。DeepSeek AI 官方账户下的模型都是经过验证的。AutoModelForCausalLM 和 AutoTokenizer 是 transformers 库的核心类，用于加载预训练模型和对应的分词器。
启动 API 服务（使用 fschat）：

为了方便外部应用调用，我们通常会将模型封装成一个兼容 OpenAI API 规范的服务。fschat 提供了一个便捷的方式。

首先，在第一个终端窗口中启动 fschat 控制器：

python -m fschat.serve.controller

这个控制器管理着模型工作节点的注册和协调。

然后，在第二个终端窗口中启动 DeepSeek 模型的工作节点 (Model Worker)。替换 YOUR_MODEL_PATH 为您模型在本地的实际路径（Hugging Face 会自动缓存模型到 ~/.cache/huggingface/hub/ 目录下）。或者，直接使用 Hugging Face ID，fschat 会尝试从 Hugging Face Hub 加载或使用缓存。

# 使用模型名称，fschat会尝试从huggingface加载或使用缓存
python -m fschat.serve.model_worker --model-path deepseek-ai/deepseek-moe-16b-chat --host 0.0.0.0 --port 21002 --gpus all --dtype bfloat16 --trust-remote-code
# `--gpus all` 表示使用所有可用GPU，`--dtype bfloat16` 指定模型加载精度
# `--trust-remote-code` 对于一些自定义模型代码是必需的

注意：如果模型较大，此步骤需要较长时间加载模型到显存。--gpus all 会尝试将模型均匀分配到所有可用 GPU 上，如果单卡显存足够，也可以指定 --gpus 0 来使用第一张卡。

最后，在第三个终端窗口中启动 API 服务器：

python -m fschat.serve.api_server --host 0.0.0.0 --port 8000

API 服务器负责将客户端请求转发给控制器，再由控制器调度到可用的模型工作节点。

出处：fschat 的使用方式和命令行参数可在 LMSYS FastChat GitHub 仓库中找到。
测试 API 服务：

通过 curl 命令或 Python 脚本测试 API。

Bash

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/deepseek-moe-16b-chat",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello, can you tell me a fun fact about cats?"}
    ],
    "temperature": 0.7,
    "max_tokens": 50
  }'

您将收到类似 OpenAI API 的 JSON 响应，包含模型的生成内容。

集群部署：Kubernetes + Helm Chart 编排

对于生产环境，单机部署的局限性显而易见。Kubernetes (K8s) 结合 Helm Chart 是实现 DeepSeek 大模型高可用、可伸缩、易管理的集群部署的理想方案。

前提条件：

一个运行中的 Kubernetes 集群（例如通过 kubeadm, k3s, EKS, AKS, GKE 等方式搭建）。
Kubernetes 集群已配置 NVIDIA GPU Operator 或手动安装了 GPU 驱动及 nvidia-container-toolkit，以确保 K8s 能够调度 GPU 资源。
已安装 kubectl 和 helm 命令行工具。
已准备 DeepSeek 模型 Docker 镜像（通常基于推理框架如 vLLM 构建）。

概念回顾：

Kubernetes Pod：K8s 中最小的可部署计算单元，可以包含一个或多个容器。
Deployment：声明式地管理 Pod 的副本数量和更新策略。
Service：定义一组 Pod 的逻辑抽象和访问策略（负载均衡）。
ConfigMap/Secret：用于存储配置数据和敏感信息。
PersistentVolume/PersistentVolumeClaim (PV/PVC)：用于提供持久化存储。
Helm Chart：K8s 应用程序的打包格式，简化部署和管理。

操作步骤：

构建 DeepSeek 模型服务 Docker 镜像：

为了在 K8s 中运行 DeepSeek 模型，我们需要将其推理服务打包成 Docker 镜像。这里我们以 vLLM 作为推理框架为例，因为它在 LLM 服务领域表现出色。

创建 Dockerfile：

# 使用包含CUDA和Python的基础镜像
# 选择与您GPU驱动和CUDA版本兼容的镜像
FROM nvcr.io/nvidia/pytorch:23.07-py3 # 或其他适合的CUDA/Python镜像

WORKDIR /app

# 安装vLLM及其依赖
RUN pip install vllm transformers torch accelerate

# 如果希望模型预加载到镜像中，取消注释并执行以下行。
# 注意：这会使镜像非常大。更推荐通过PersistentVolumeClaim挂载模型。
# RUN python -c "from transformers import AutoTokenizer, AutoModelForCausalLM; AutoTokenizer.from_pretrained('deepseek-ai/deepseek-moe-16b-chat', trust_remote_code=True); AutoModelForCausalLM.from_pretrained('deepseek-ai/deepseek-moe-16b-chat', trust_remote_code=True)"

# 暴露vLLM服务的端口
EXPOSE 8000

# 启动vLLM服务
# --model 指定模型路径或Hugging Face ID
# --trust-remote-code 适用于一些DeepSeek模型需要运行自定义代码
# --tensor-parallel-size 用于多卡推理的张量并行数，根据实际GPU数量调整
# --dtype bfloat16 或 float16，与模型加载精度一致
CMD ["python", "-m", "vllm.entrypoints.api_server", "--host", "0.0.0.0", "--port", "8000", "--model", "deepseek-ai/deepseek-moe-16b-chat", "--tensor-parallel-size", "1", "--dtype", "bfloat16", "--trust-remote-code"]

出处：vLLM 的命令行参数和 Docker 部署方式可以在 vLLM GitHub 仓库的文档中找到。基础镜像通常来自 NVIDIA NGC 容器注册表，确保 CUDA 和 PyTorch 环境的兼容性。

构建并推送 Docker 镜像（替换 your-registry 为您的 Docker 仓库地址）：

docker build -t your-registry/deepseek-vllm:latest .
docker push your-registry/deepseek-vllm:latest

创建 Helm Chart：

Helm Chart 是 K8s 应用程序的打包工具，可以定义 Deployment、Service、ConfigMap 等 K8s 资源。

创建 Chart 目录结构：

helm create deepseek-llm-chart
cd deepseek-llm-chart

修改 values.yaml（这个文件定义了 Chart 的可配置参数）：

# deepseek-llm-chart/values.yaml
replicaCount: 1 # 模型服务副本数，根据需求和可用GPU资源调整

image:
  repository: your-registry/deepseek-vllm # 替换为你的Docker镜像地址
  tag: latest # 替换为你的镜像标签
  pullPolicy: IfNotPresent # 如果本地有同名镜像则不重新拉取

service:
  type: ClusterIP # 或 NodePort, LoadBalancer，根据访问需求选择
  port: 8000 # 容器暴露的端口

resources:
  limits:
    nvidia.com/gpu: 1 # 每个Pod使用1块GPU，确保K8s集群已配置GPU调度
    memory: "64Gi" # 限制Pod最大内存使用
    cpu: "16" # 限制Pod最大CPU使用
  requests:
    nvidia.com/gpu: 1 # 请求1块GPU
    memory: "32Gi" # 请求32Gi内存
    cpu: "8" # 请求8核CPU

# 如果模型通过PersistentVolumeClaim (PVC) 挂载，配置以下部分
# persistentVolumeClaim:
#   enabled: false # 设置为true启用PVC
#   name: deepseek-model-pvc # PVC的名称，需要提前创建
#   mountPath: /models # 模型文件在容器内部的挂载路径
#   size: 200Gi # PVC的存储大小，根据模型和缓存大小调整
#   accessModes:
#     - ReadOnlyMany # 或 ReadWriteOnce, ReadWriteMany，根据共享方式选择

修改 templates/deployment.yaml：

确保 Pod 模板中的 containers 部分正确引用了镜像和资源限制，并添加 GPU 资源请求。如果使用 PVC 挂载模型，也需要在此处添加 volumeMounts 和 volumes 配置。

YAML

# deepseek-llm-chart/templates/deployment.yaml (部分关键内容)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "deepseek-llm-chart.fullname" . }}
  labels:
    {{- include "deepseek-llm-chart.labels" . | nindent 4 }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "deepseek-llm-chart.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      {{- with .Values.podAnnotations }}
      annotations:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      labels:
        {{- include "deepseek-llm-chart.selectorLabels" . | nindent 12 }}
    spec:
      # serviceAccountName: {{ include "deepseek-llm-chart.serviceAccountName" . }} # 如果需要Service Account
      securityContext:
        {{- toYaml .Values.podSecurityContext | nindent 12 }}
      containers:
        - name: {{ .Chart.Name }}
          securityContext:
            {{- toYaml .Values.securityContext | nindent 16 }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - name: http
              containerPort: {{ .Values.service.port }}
              protocol: TCP
          resources:
            {{- toYaml .Values.resources | nindent 16 }}
          # 如果通过PVC挂载模型，添加volumeMounts
          # volumeMounts:
          #   - name: model-storage
          #     mountPath: {{ .Values.persistentVolumeClaim.mountPath }} # 容器内部模型路径
      # 如果通过PVC挂载模型，添加volumes
      # volumes:
      #   - name: model-storage
      #     persistentVolumeClaim:
      #       claimName: {{ .Values.persistentVolumeClaim.name }}
      {{- with .Values.nodeSelector }}
      nodeSelector: # 允许将Pod调度到特定节点
        {{- toYaml . | nindent 12 }}
      {{- end }}
      {{- with .Values.affinity }}
      affinity: # 更复杂的调度规则
        {{- toYaml . | nindent 12 }}
      {{- end }}
      {{- with .Values.tolerations }}
      tolerations: # 允许Pod调度到被污染的节点
        {{- toYaml . | nindent 12 }}
      {{- end }}

出处：Kubernetes Deployment 和 Service 的 YAML 结构是 K8s 官方文档的规范。Helm Chart 的结构也是 Helm 官方文档定义的。
部署 Helm Chart：

在 deepseek-llm-chart 目录下执行：

helm install deepseek-llm deepseek-llm-chart/

验证部署：

kubectl get pods -l app.kubernetes.io/instance=deepseek-llm # 查看Pod状态
kubectl get svc deepseek-llm-chart # 查看Service信息

通过 Service 的 IP 和端口，即可访问部署在 K8s 集群中的 DeepSeek 模型服务。如果 Service Type 是 LoadBalancer，则可以通过外部 IP 访问。

模型量化部署（4bit/8bit GGUF 实战）

模型量化是降低模型显存占用、提升推理速度的关键技术。GGUF 格式因其良好的兼容性和量化支持，成为私有化部署中的热门选择，尤其适用于 CPU 或显存有限的 GPU 环境。

前提条件：

已安装 llama-cpp-python 库。
已安装 auto-gptq 或 ctransformers 等工具，用于模型量化（如果模型是原始 FP16/BF16 格式）。
具备足够的 CPU 内存（量化过程可能需要大量 CPU 内存，通常是模型大小的数倍）。

操作步骤：

安装所需库：

Bash

pip install llama-cpp-python
pip install "auto-gptq[dev]" # 或者 pip install ctransformers

出处：llama-cpp-python 是 llama.cpp 的 Python 绑定，其安装和使用说明可在 llama-cpp-python GitHub 仓库找到。auto-gptq 是 GPTQ 量化工具，其项目地址为 AutoGPTQ GitHub 仓库。
转换模型为 GPTQ 格式 (可选，如果 DeepSeek 模型是原始 FP16/BF16 格式)：

如果您的 DeepSeek 模型尚未量化，可以使用 auto-gptq 工具将其转换为 4-bit 或 8-bit GPTQ 格式。这步通常在 GPU 上执行。

Python

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer
import torch

model_name = "deepseek-ai/deepseek-moe-16b-chat" # 原始模型名称
quantized_model_dir = "./deepseek-moe-16b-chat-4bit-gptq" # 量化后模型保存路径

# 加载原始模型和tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
# 使用float16加载，降低显存占用
model = AutoGPTQForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, low_cpu_mem_usage=True, trust_remote_code=True)

# 定义量化配置
quantize_config = BaseQuantizeConfig(
    bits=4,  # 量化到4比特
    group_size=128, # 量化组大小
    desc_act=False, # 是否按激活值排序，通常False即可
    # calibration_dataset_name="wikitext2", # 用于校准的数据集，可选，提高精度
    # quant_method="gptq", # 显式指定量化方法
)

# 执行量化
# 注意：量化过程可能需要较长时间和大量内存，确保有足够的RAM和GPU显存
print("Starting GPTQ quantization...")
model.quantize(tokenizer, quantize_config=quantize_config)
print("Quantization complete. Saving model...")

# 保存量化后的模型
model.save_pretrained(quantized_model_dir, tokenizer=tokenizer)
print(f"Quantized model saved to {quantized_model_dir}")

转换模型为 GGUF 格式：

一旦模型被量化为 Hugging Face 格式（或直接从 Hugging Face 下载了已经量化为 Hugging Face 格式的模型），我们可以使用 llama.cpp 提供的工具链中的 convert.py 脚本将其转换为 GGUF 格式。

首先，克隆 llama.cpp 仓库并安装其依赖：

Bash

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
pip install -r requirements.txt

然后，运行转换脚本。假设您已经将 DeepSeek 模型的 Hugging Face 格式版本（无论是原始 FP16/BF16 还是 GPTQ 量化版）下载或保存到了 ./deepseek-moe-16b-chat 或 ./deepseek-moe-16b-chat-4bit-gptq 目录。

Bash

# 假设你已经下载了Hugging Face格式的deepseek-moe-16b-chat到 ./deepseek-moe-16b-chat 目录
# 如果你刚通过auto-gptq量化并保存到 `./deepseek-moe-16b-chat-4bit-gptq`，请使用那个路径作为输入
HF_MODEL_PATH="./deepseek-moe-16b-chat" # 或者 "./deepseek-moe-16b-chat-4bit-gptq"
GGUF_OUTPUT_FILE="../deepseek-moe-16b-chat-q4_0.gguf" # 输出GGUF文件名

# 运行转换脚本。
# --outtype q4_0 表示4bit量化 (如果输入已经是量化模型，会尝试保持精度)
# --outtype q8_0 表示8bit量化
# --outtype f16 表示16bit浮点数 (如果从原始模型转换)
python convert.py ${HF_MODEL_PATH} --outtype q4_0 --outfile ${GGUF_OUTPUT_FILE}

出处：llama.cpp 的模型转换工具和用法都在其 官方 GitHub 仓库 中，convert.py 是其核心脚本之一。
使用 llama-cpp-python 部署 GGUF 模型：

llama-cpp-python 是 llama.cpp 的 Python 绑定，可以加载 GGUF 格式的模型，并在 CPU 和 GPU 上进行高效推理。

Python

from llama_cpp import Llama
from fastapi import FastAPI
from pydantic import BaseModel
import uvicorn
import os

# 确保 GGUF 模型文件存在
model_path = "./deepseek-moe-16b-chat-q4_0.gguf"
if not os.path.exists(model_path):
    print(f"Error: GGUF model file not found at {model_path}. Please run conversion steps first.")
    exit(1)

# 加载GGUF模型
# n_gpu_layers=-1 表示将所有可能的层加载到GPU，以最大化GPU利用率。
# n_ctx 定义了上下文窗口大小。
llm = Llama(model_path=model_path,
            n_ctx=4096, # 根据模型和需求调整上下文窗口
            n_gpu_layers=-1, # 将所有可加载到GPU的层都加载到GPU上
            verbose=True) # 开启详细日志

app = FastAPI()

class ChatRequest(BaseModel):
    prompt: str
    max_tokens: int = 256
    temperature: float = 0.7
    top_p: float = 0.9

@app.post("/generate")
async def generate_text(request: ChatRequest):
    try:
        output = llm(
            request.prompt,
            max_tokens=request.max_tokens,
            temperature=request.temperature,
            top_p=request.top_p,
            stop=["<|eot_id|>", "</s>"], # DeepSeek 通常的停止词
            echo=False # 不返回原始prompt
        )
        return {"response": output["choices"][0]["text"]}
    except Exception as e:
        return {"error": str(e)}, 500

# 运行API服务
# 在终端执行：uvicorn your_script_name:app --host 0.0.0.0 --port 8001
# 请将 your_script_name 替换为保存此Python代码的文件名 (例如: deepseek_api.py)

出处：llama-cpp-python 的 API 使用方式可以在其 GitHub 仓库 中找到。FastAPI 是一个流行的 Python Web 框架，其使用方式可在 FastAPI 官方文档中找到。

模型热更新与版本管理

在生产环境中，模型需要不断迭代更新，同时要保证服务的连续性。模型热更新和版本管理是实现这一目标的关键策略。

模型热更新：

“热更新”指的是在不停止现有服务的情况下，加载新版本的模型。这通常通过以下方式实现：

进程内更新 (In-process update)：某些推理框架（如 Triton Inference Server, SGLang）支持在运行时加载/卸载模型，允许您更新模型文件后通知服务重新加载。这需要推理服务本身具备这种能力。
滚动更新 (Rolling Update)：这是 Kubernetes 中实现热更新的常用策略。当您更新 Deployment 的 Docker 镜像标签或配置时，K8s 会逐个终止旧的 Pod，并启动新的 Pod。在旧 Pod 完全终止前，新的 Pod 已经开始提供服务，从而实现零停机更新。
蓝绿部署 (Blue/Green Deployment)：部署一个与当前生产环境（蓝色环境）完全独立的新环境（绿色环境），在新环境上部署新模型并进行充分测试。测试通过后，将流量从蓝色环境一次性切换到绿色环境。这种方式风险最低，但资源消耗较高。
金丝雀发布 (Canary Release)：新模型版本首先只向一小部分用户（“金丝雀”）发布，如果反馈良好，则逐步扩大发布范围，直至完全取代旧版本。这允许您在全面发布前发现潜在问题。
版本管理策略：

良好的版本管理对于模型的生命周期至关重要，包括模型权重版本、Docker 镜像版本和 Helm Chart 版本。

模型权重版本：
- 将不同版本的 DeepSeek 模型权重（无论是原始的、微调的还是量化的）存储在对象存储（如 S3, MinIO）或私有模型仓库（如 MLflow Model Registry, Hugging Face Hub 私有仓库）中，并用明确的标签或哈希值进行版本标记。
- 例如：deepseek-moe-16b-chat-v1.0-fp16, deepseek-moe-16b-chat-v1.1-q4_0。
Docker 镜像版本：
- 为每个模型服务 Docker 镜像打上清晰的版本标签，例如 your-registry/deepseek-vllm:1.0.0, your-registry/deepseek-vllm:1.1.0-deepseek-moe-16b-chat-q4_0。
- 确保 Dockerfile 中的模型路径或 Hugging Face ID 与镜像版本对应。
Helm Chart 版本：
- 每次对 K8s 部署配置（values.yaml, templates/*.yaml）进行重大更改时，更新 Helm Chart 的 Chart.yaml 中的 version 字段。
- 这允许您使用 helm rollback 命令轻松回滚到旧的部署配置。

实现示例 (Kubernetes 滚动更新)：

当您更新 DeepSeek 模型服务对应的 Docker 镜像时，只需修改 Helm Chart 的 values.yaml 或直接使用 kubectl set image 命令，Kubernetes 就会自动执行滚动更新。

更新 values.yaml 中的镜像版本：

# deepseek-llm-chart/values.yaml
image:
  repository: your-registry/deepseek-vllm
  tag: new-model-version # 将这里更改为新的镜像标签，例如 1.1.0
  pullPolicy: IfNotPresent

应用 Helm Chart 更新：

在 deepseek-llm-chart 目录下执行：

helm upgrade deepseek-llm deepseek-llm-chart/

Kubernetes 将会逐个替换 Pod，确保服务不中断。您可以通过 kubectl rollout status deployment/deepseek-llm 命令监控更新进度。

回滚（如果新版本有问题）：

如果新版本出现问题，可以快速回滚到上一个稳定的版本：

helm rollback deepseek-llm

或者回滚到特定历史版本：

helm rollback deepseek-llm [REVISION_NUMBER]

您可以使用 helm history deepseek-llm 查看所有历史版本及其对应的修订号。

通过以上部署实战内容，您应该对 DeepSeek 大模型的私有化部署有了更清晰的认识，并具备了从单机到集群、从量化到版本管理的基本操作能力。

参考资源列表

Hugging Face transformers 库：
GitHub: https://github.com/huggingface/transformers
文档: https://huggingface.co/docs/transformers/index
DeepSeek AI Hugging Face 模型 Hu：
DeepSeek AI Models: https://huggingface.co/deepseek-ai
FastChat (fschat)：
GitHub: https://github.com/lmsys/FastChat
vLLM 官方文档：
GitHub: https://github.com/vllm-project/vllm
文档: https://docs.vllm.ai/en/latest/
NVIDIA NGC 容器注册表：
NVIDIA NGC: https://catalog.ngc.nvidia.com/
Docker 官方文档：
https://docs.docker.com/
Kubernetes 官方文档：
https://kubernetes.io/docs/
Kubernetes GPU 支持: https://kubernetes.io/docs/tasks/manage-gpus/scheduling-gpus/
Helm 官方文档：
https://helm.sh/docs/
llama.cpp 项目：
GitHub: https://github.com/ggerganov/llama.cpp
llama-cpp-python 项目：
GitHub: https://github.com/abetlen/llama-cpp-python
auto-gptq 项目：
GitHub: https://github.com/AutoGPTQ/AutoGPTQ
FastAPI 官方文档：
https://fastapi.tiangolo.com/